Freelog 125/Freelog_MarsAvril2015_No125.iso/Musique/Quod Libet/quodlibet-3.3.0-installer.exe/bin/multiprocessing/__init__.pyc

Python Compiled Bytecode | 2014-12-31 | 8KB | 281 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.7)

__version__ = '0.70a1'
__all__ = [
    'Process',
    'current_process',
    'active_children',
    'freeze_support',
    'Manager',
    'Pipe',
    'cpu_count',
    'log_to_stderr',
    'get_logger',
    'allow_connection_pickling',
    'BufferTooShort',
    'TimeoutError',
    'Lock',
    'RLock',
    'Semaphore',
    'BoundedSemaphore',
    'Condition',
    'Event',
    'Queue',
    'JoinableQueue',
    'Pool',
    'Value',
    'Array',
    'RawValue',
    'RawArray',
    'SUBDEBUG',
    'SUBWARNING']
__author__ = 'R. Oudkerk ([e-mail])'
import os
import sys
from multiprocessing.process import Process, current_process, active_children
from multiprocessing.util import SUBDEBUG, SUBWARNING

class ProcessError(Exception):
    pass


class BufferTooShort(ProcessError):
    pass


class TimeoutError(ProcessError):
    pass


class AuthenticationError(ProcessError):
    pass

import _multiprocessing

def Manager():
    '''
    Returns a manager associated with a running server process

    The managers methods such as `Lock()`, `Condition()` and `Queue()`
    can be used to create shared objects.
    '''
    SyncManager = SyncManager
    import multiprocessing.managers
    m = SyncManager()
    m.start()
    return m


def Pipe(duplex = True):
    '''
    Returns two connection object connected by a pipe
    '''
    Pipe = Pipe
    import multiprocessing.connection
    return Pipe(duplex)


def cpu_count():
    '''
    Returns the number of CPUs in the system
    '''
    if sys.platform == 'win32':

        try:
            num = int(os.environ['NUMBER_OF_PROCESSORS'])
        except (ValueError, KeyError):
            num = 0


    if 'bsd' in sys.platform or sys.platform == 'darwin':
        comm = '/sbin/sysctl -n hw.ncpu'
        if sys.platform == 'darwin':
            comm = '/usr' + comm

        try:
            with os.popen(comm) as p:
                num = int(p.read())
        except ValueError:
            num = 0



    try:
        num = os.sysconf('SC_NPROCESSORS_ONLN')
    except (ValueError, OSError, AttributeError):
        num = 0

    if num >= 1:
        return num
    raise None('cannot determine number of cpus')


def freeze_support():
    '''
    Check whether this is a fake forked process in a frozen executable.
    If so then run code specified by commandline and exit.
    '''
    if sys.platform == 'win32' and getattr(sys, 'frozen', False):
        freeze_support = freeze_support
        import multiprocessing.forking
        freeze_support()


def get_logger():
    '''
    Return package logger -- if it does not already exist then it is created
    '''
    get_logger = get_logger
    import multiprocessing.util
    return get_logger()


def log_to_stderr(level = None):
    '''
    Turn on logging and add a handler which prints to stderr
    '''
    log_to_stderr = log_to_stderr
    import multiprocessing.util
    return log_to_stderr(level)


def allow_connection_pickling():
    '''
    Install support for sending connections and sockets between processes
    '''
    reduction = reduction
    import multiprocessing


def Lock():
    '''
    Returns a non-recursive lock object
    '''
    Lock = Lock
    import multiprocessing.synchronize
    return Lock()


def RLock():
    '''
    Returns a recursive lock object
    '''
    RLock = RLock
    import multiprocessing.synchronize
    return RLock()


def Condition(lock = None):
    '''
    Returns a condition object
    '''
    Condition = Condition
    import multiprocessing.synchronize
    return Condition(lock)


def Semaphore(value = 1):
    '''
    Returns a semaphore object
    '''
    Semaphore = Semaphore
    import multiprocessing.synchronize
    return Semaphore(value)


def BoundedSemaphore(value = 1):
    '''
    Returns a bounded semaphore object
    '''
    BoundedSemaphore = BoundedSemaphore
    import multiprocessing.synchronize
    return BoundedSemaphore(value)


def Event():
    '''
    Returns an event object
    '''
    Event = Event
    import multiprocessing.synchronize
    return Event()


def Queue(maxsize = 0):
    '''
    Returns a queue object
    '''
    Queue = Queue
    import multiprocessing.queues
    return Queue(maxsize)


def JoinableQueue(maxsize = 0):
    '''
    Returns a queue object
    '''
    JoinableQueue = JoinableQueue
    import multiprocessing.queues
    return JoinableQueue(maxsize)


def Pool(processes = None, initializer = None, initargs = (), maxtasksperchild = None):
    '''
    Returns a process pool object
    '''
    Pool = Pool
    import multiprocessing.pool
    return Pool(processes, initializer, initargs, maxtasksperchild)


def RawValue(typecode_or_type, *args):
    '''
    Returns a shared object
    '''
    RawValue = RawValue
    import multiprocessing.sharedctypes
    return RawValue(typecode_or_type, *args)


def RawArray(typecode_or_type, size_or_initializer):
    '''
    Returns a shared array
    '''
    RawArray = RawArray
    import multiprocessing.sharedctypes
    return RawArray(typecode_or_type, size_or_initializer)


def Value(typecode_or_type, *args, **kwds):
    '''
    Returns a synchronized shared object
    '''
    Value = Value
    import multiprocessing.sharedctypes
    return Value(typecode_or_type, *args, **kwds)


def Array(typecode_or_type, size_or_initializer, **kwds):
    '''
    Returns a synchronized shared array
    '''
    Array = Array
    import multiprocessing.sharedctypes
    return Array(typecode_or_type, size_or_initializer, **kwds)

if sys.platform == 'win32':

    def set_executable(executable):
        '''
        Sets the path to a python.exe or pythonw.exe binary used to run
        child processes on Windows instead of sys.executable.
        Useful for people embedding Python.
        '''
        set_executable = set_executable
        import multiprocessing.forking
        set_executable(executable)

    __all__ += [
        'set_executable']